# gui/widgets/fast_signal_plots.py
"""
高性能信号绘图组件 - 使用PyQtGraph替代matplotlib
性能比matplotlib快10-100倍，专为实时数据设计
"""

from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
import numpy as np

# 尝试导入PyQtGraph作为高性能替代
try:
    import pyqtgraph as pg

    # 首先尝试启用OpenGL加速
    try:
        # 检查OpenGL是否可用
        import OpenGL.GL as gl
        pg.setConfigOptions(
            antialias=True,
            useOpenGL=True,   # 启用OpenGL加速以获得最佳性能
            enableExperimental=True
        )
        print("[BOOST] PyQtGraph可用 - OpenGL硬件加速已启用")
    except ImportError:
        # OpenGL模块不可用，使用软件渲染
        pg.setConfigOptions(
            antialias=True,
            useOpenGL=False,  # 回退到软件渲染
            enableExperimental=True
        )
        print("[INFO] PyQtGraph可用 - 使用软件渲染 (安装PyOpenGL可启用硬件加速)")
    except Exception as e:
        # 其他OpenGL初始化失败，回退到软件渲染
        print(f"[WARN] OpenGL初始化失败，使用软件渲染: {e}")
        pg.setConfigOptions(
            antialias=True,
            useOpenGL=False,  # 回退到软件渲染
            enableExperimental=True
        )
        print("[INFO] PyQtGraph可用 - 使用软件渲染")

    PYQTGRAPH_AVAILABLE = True

except ImportError:
    PYQTGRAPH_AVAILABLE = False
    print("[ERROR] PyQtGraph不可用 - 请安装: pip install pyqtgraph")

class FastSignalPlotWidget(QWidget):
    """高性能信号显示组件 - 使用PyQtGraph"""

    def __init__(self, title="Signal", parent=None):
        super().__init__(parent)
        self.title = title
        self.init_ui()

    def init_ui(self):
        """初始化UI"""
        layout = QVBoxLayout(self)

        if not PYQTGRAPH_AVAILABLE:
            # 如果PyQtGraph不可用，显示提示
            label = QLabel("PyQtGraph不可用\n请安装: pip install pyqtgraph\n以获得高性能绘图")
            label.setAlignment(Qt.AlignCenter)
            label.setStyleSheet("color: #f85149; font-size: 14px; padding: 20px;")
            layout.addWidget(label)
            return

        try:
            # 创建PyQtGraph图形布局
            self.graphics_layout = pg.GraphicsLayoutWidget()
            self.graphics_layout.setBackground('#0d1117')  # 深色背景

            # 创建两个子图：时域和频域
            self.time_plot = self.graphics_layout.addPlot(title=f"{self.title} - 时域")
            self.graphics_layout.nextRow()
            self.freq_plot = self.graphics_layout.addPlot(title=f"{self.title} - 频域")

            # 设置样式
            self.setup_plot_style(self.time_plot, "时间 (μs)", "幅度")
            self.setup_plot_style(self.freq_plot, "频率 (MHz)", "幅度 (dB)")

            # 启用鼠标交互功能
            self.enable_mouse_interaction()

            # 用于存储绘图曲线
            self.time_curves = {}  # 存储时域曲线
            self.freq_curves = {}  # 存储频域曲线

            layout.addWidget(self.graphics_layout)

        except Exception as e:
            # 如果PyQtGraph初始化失败，显示错误并降级到提示
            print(f"PyQtGraph初始化失败: {e}")
            label = QLabel(f"PyQtGraph初始化失败\n错误: {str(e)}\n请检查PyQtGraph安装")
            label.setAlignment(Qt.AlignCenter)
            label.setStyleSheet("color: #f85149; font-size: 12px; padding: 20px;")
            layout.addWidget(label)

    def clear_plots(self):
        """清空绘图区域 - 提供与matplotlib兼容的接口"""
        if PYQTGRAPH_AVAILABLE and hasattr(self, 'time_plot') and hasattr(self, 'freq_plot'):
            try:
                self.time_plot.clear()
                self.freq_plot.clear()
                self.time_curves.clear()
                self.freq_curves.clear()
                # 重置信号类型和范围初始化标志
                if hasattr(self, '_last_signal_type'):
                    delattr(self, '_last_signal_type')
                if hasattr(self, '_range_initialized'):
                    self._range_initialized = False
            except Exception as e:
                print(f"清空PyQtGraph信号图失败: {e}")

    def setup_plot_style(self, plot_item, xlabel, ylabel):
        """设置绘图样式"""
        # 设置标签
        plot_item.setLabel('bottom', xlabel, color='#58a6ff', size='12pt')
        plot_item.setLabel('left', ylabel, color='#58a6ff', size='12pt')

        # 设置网格
        plot_item.showGrid(x=True, y=True, alpha=0.3)

        # 设置坐标轴颜色
        axis_pen = pg.mkPen(color='#30363d', width=1)
        plot_item.getAxis('bottom').setPen(axis_pen)
        plot_item.getAxis('left').setPen(axis_pen)

        # 设置文字颜色
        plot_item.getAxis('bottom').setTextPen('#f0f6fc')
        plot_item.getAxis('left').setTextPen('#f0f6fc')

    def enable_mouse_interaction(self):
        """启用鼠标交互功能（选框放大、滚轮缩放、右键拖拽）"""
        try:
            # 为时域子图启用交互
            if hasattr(self, 'time_plot'):
                # 启用鼠标控制
                # 左键拖拽选框放大
                # 右键拖拽平移
                # 滚轮缩放
                self.time_plot.setMouseEnabled(x=True, y=True)

                # 获取ViewBox并设置鼠标模式
                vb_time = self.time_plot.getViewBox()
                vb_time.setMouseMode(pg.ViewBox.RectMode)  # 默认选框模式

                # 启用右键菜单（可以切换鼠标模式、自动范围等）
                self.time_plot.setMenuEnabled(True)

            # 为频域子图启用交互
            if hasattr(self, 'freq_plot'):
                self.freq_plot.setMouseEnabled(x=True, y=True)

                vb_freq = self.freq_plot.getViewBox()
                vb_freq.setMouseMode(pg.ViewBox.RectMode)

                self.freq_plot.setMenuEnabled(True)

            print(f"[INFO] {self.title}: 鼠标交互已启用 - 左键选框放大, 右键拖拽平移, 滚轮缩放, 右键菜单重置")

        except Exception as e:
            print(f"启用鼠标交互失败: {e}")

    def plot_signal(self, time_data, signal_data, signal_type='complex'):
        """
        绘制信号 - 优化版：复用曲线对象而不是每次clear
        Args:
            time_data: 时间轴数据
            signal_data: 信号数据
            signal_type: 'complex', 'real', 'magnitude', 'compressed'
                - 'complex': 上图显示实部和虚部，下图显示频谱
                - 'compressed': 上图显示实部，下图显示虚部（用于脉冲压缩信号）
                - 'magnitude': 上图显示幅度，下图显示频谱
                - 'real': 上图显示实数信号，下图显示频谱
        """
        if not PYQTGRAPH_AVAILABLE:
            return

        try:
            # 不再每次clear，而是检查并复用已有曲线
            # 只在信号类型改变时才clear
            if not hasattr(self, '_last_signal_type') or self._last_signal_type != signal_type:
                self.time_plot.clear()
                self.freq_plot.clear()
                self.time_curves.clear()
                self.freq_curves.clear()
                self._last_signal_type = signal_type
                # 信号类型改变，需要重新计算范围
                self._range_initialized = False

            if len(time_data) == 0 or len(signal_data) == 0:
                return

            # 时间轴转换为微秒
            time_data_us = time_data * 1e6

            # 绘制时域信号 - 使用setData()复用曲线对象
            if signal_type == 'compressed':
                # 脉冲压缩信号：上图显示实部，下图显示虚部
                real_pen = pg.mkPen(color='#58a6ff', width=1.5)
                imag_pen = pg.mkPen(color='#f85149', width=1.5)

                # 上图：实部
                self.time_plot.setLabel('left', '实部', color='#58a6ff', size='12pt')
                if 'real' not in self.time_curves:
                    # 首次创建曲线
                    self.time_curves['real'] = self.time_plot.plot(
                        time_data_us, np.real(signal_data),
                        pen=real_pen, name='实部'
                    )
                else:
                    # 复用已有曲线，只更新数据
                    self.time_curves['real'].setData(time_data_us, np.real(signal_data))

                # 下图：虚部
                self.freq_plot.setLabel('bottom', '时间 (μs)', color='#58a6ff', size='12pt')
                self.freq_plot.setLabel('left', '虚部', color='#58a6ff', size='12pt')
                if 'imag' not in self.freq_curves:
                    # 首次创建曲线
                    self.freq_curves['imag'] = self.freq_plot.plot(
                        time_data_us, np.imag(signal_data),
                        pen=imag_pen, name='虚部'
                    )
                else:
                    # 复用已有曲线，只更新数据
                    self.freq_curves['imag'].setData(time_data_us, np.imag(signal_data))

            elif signal_type == 'complex':
                # 复信号：分别绘制实部和虚部
                real_pen = pg.mkPen(color='#58a6ff', width=1.5)
                imag_pen = pg.mkPen(color='#f85149', width=1.5)

                if 'real' not in self.time_curves:
                    # 首次创建曲线
                    self.time_curves['real'] = self.time_plot.plot(
                        time_data_us, np.real(signal_data),
                        pen=real_pen, name='实部'
                    )
                else:
                    # 复用已有曲线，只更新数据
                    self.time_curves['real'].setData(time_data_us, np.real(signal_data))

                if 'imag' not in self.time_curves:
                    # 首次创建曲线
                    self.time_curves['imag'] = self.time_plot.plot(
                        time_data_us, np.imag(signal_data),
                        pen=imag_pen, name='虚部'
                    )
                else:
                    # 复用已有曲线，只更新数据
                    self.time_curves['imag'].setData(time_data_us, np.imag(signal_data))

                # 频域：计算并显示FFT
                self.plot_fft(signal_data, time_data)

            elif signal_type == 'magnitude':
                # 幅度信号
                mag_pen = pg.mkPen(color='#2ea043', width=1.5)
                magnitude_data = np.abs(signal_data)

                if 'magnitude' not in self.time_curves:
                    # 首次创建曲线
                    self.time_curves['magnitude'] = self.time_plot.plot(
                        time_data_us, magnitude_data,
                        pen=mag_pen, name='幅度'
                    )
                else:
                    # 复用已有曲线，只更新数据
                    self.time_curves['magnitude'].setData(time_data_us, magnitude_data)

                # 频域：计算并显示FFT
                self.plot_fft(signal_data, time_data)

            else:
                # 实数信号
                real_pen = pg.mkPen(color='#58a6ff', width=1.5)

                if 'signal' not in self.time_curves:
                    # 首次创建曲线
                    self.time_curves['signal'] = self.time_plot.plot(
                        time_data_us, signal_data,
                        pen=real_pen, name='信号'
                    )
                else:
                    # 复用已有曲线，只更新数据
                    self.time_curves['signal'].setData(time_data_us, signal_data)

                # 频域：计算并显示FFT
                self.plot_fft(signal_data, time_data)

            # 智能自动调整范围
            # 策略：信号类型改变时必须调整，其他时候根据信号幅度变化判断是否需要调整
            need_autorange = False

            if not hasattr(self, '_range_initialized') or not self._range_initialized:
                # 首次绘制，必须调整
                need_autorange = True
                self._range_initialized = True
            else:
                # 非首次绘制，检查信号幅度是否超出当前范围
                try:
                    # 获取当前y轴范围
                    time_y_range = self.time_plot.viewRange()[1]
                    freq_y_range = self.freq_plot.viewRange()[1]

                    # 获取信号幅度范围
                    if signal_type == 'compressed' or signal_type == 'complex':
                        signal_min = min(np.min(np.real(signal_data)), np.min(np.imag(signal_data)))
                        signal_max = max(np.max(np.real(signal_data)), np.max(np.imag(signal_data)))
                    else:
                        signal_min = np.min(signal_data)
                        signal_max = np.max(signal_data)

                    # 如果信号超出当前范围的80%，则需要重新调整
                    range_margin = 0.8
                    if (signal_min < time_y_range[0] * range_margin or
                        signal_max > time_y_range[1] * range_margin or
                        signal_max < time_y_range[1] * 0.2):  # 信号太小也需要调整
                        need_autorange = True
                except:
                    # 出错时强制调整
                    need_autorange = True

            if need_autorange:
                self.time_plot.autoRange()
                self.freq_plot.autoRange()

        except Exception as e:
            print(f"PyQtGraph绘图错误: {e}")

    def plot_fft(self, signal_data, time_data):
        """计算并绘制FFT频谱 - 优化版：复用曲线对象"""
        try:
            if len(signal_data) < 2:
                return

            # 计算FFT
            fft_data = np.fft.fft(signal_data)
            freqs = np.fft.fftfreq(len(signal_data), d=(time_data[1] - time_data[0]))

            # 基带信号频谱：显示完整频率范围 -Fs/2 到 Fs/2
            # 使用fftshift将零频率移到中心
            freqs_shifted = np.fft.fftshift(freqs)
            fft_shifted = np.fft.fftshift(fft_data)

            # 转换为dB
            fft_magnitude = 20 * np.log10(np.abs(fft_shifted) + 1e-12)

            # 绘制频谱 - 使用setData()复用曲线对象
            freq_pen = pg.mkPen(color='#fd7e14', width=1.5)
            if 'spectrum' not in self.freq_curves:
                # 首次创建频谱曲线
                self.freq_curves['spectrum'] = self.freq_plot.plot(
                    freqs_shifted / 1e6, fft_magnitude,  # 转换为MHz
                    pen=freq_pen, name='频谱'
                )
            else:
                # 复用已有曲线，只更新数据
                self.freq_curves['spectrum'].setData(freqs_shifted / 1e6, fft_magnitude)

        except Exception as e:
            print(f"FFT计算错误: {e}")

class FastRangeDopplerWidget(QWidget):
    """高性能距离-多普勒图组件 - 使用PlotItem提供更好的科学可视化"""

    def __init__(self, parent=None):
        super().__init__(parent)
        self.detection_items = []  # 存储检测点标记
        self.init_ui()

    def init_ui(self):
        """初始化UI"""
        layout = QVBoxLayout(self)

        if not PYQTGRAPH_AVAILABLE:
            label = QLabel("PyQtGraph不可用\n请安装: pip install pyqtgraph")
            label.setAlignment(Qt.AlignCenter)
            label.setStyleSheet("color: #f85149; font-size: 14px; padding: 20px;")
            layout.addWidget(label)
            return

        try:
            # 创建GraphicsLayoutWidget用于更灵活的布局
            self.graphics_layout = pg.GraphicsLayoutWidget()
            self.graphics_layout.setBackground('#0d1117')  # 深色背景

            # 创建PlotItem用于显示RD图
            self.plot_item = self.graphics_layout.addPlot(title="距离-多普勒图")

            # 设置坐标轴标签
            self.plot_item.setLabel('bottom', '距离', units='km', color='#58a6ff', size='12pt')
            self.plot_item.setLabel('left', '多普勒频率', units='Hz', color='#58a6ff', size='12pt')

            # 设置网格
            self.plot_item.showGrid(x=True, y=True, alpha=0.3)

            # 设置坐标轴颜色
            axis_pen = pg.mkPen(color='#30363d', width=1)
            self.plot_item.getAxis('bottom').setPen(axis_pen)
            self.plot_item.getAxis('left').setPen(axis_pen)
            self.plot_item.getAxis('bottom').setTextPen('#f0f6fc')
            self.plot_item.getAxis('left').setTextPen('#f0f6fc')

            # 创建ImageItem用于显示RD图数据
            self.image_item = pg.ImageItem()
            self.plot_item.addItem(self.image_item)

            # 设置颜色映射 - 使用热图配色方案
            try:
                # 尝试使用jet颜色映射（经典的热图配色）
                colormap = pg.colormap.get('CET-L9')  # 类似jet的颜色映射
                self.image_item.setColorMap(colormap)
            except:
                try:
                    # 回退到viridis
                    colormap = pg.colormap.get('viridis')
                    self.image_item.setColorMap(colormap)
                except:
                    # 使用默认颜色映射
                    pass

            # 添加颜色条
            self.colorbar = pg.ColorBarItem(
                values=(0, 100),  # 初始值范围，实际绘图时会更新
                colorMap=colormap if 'colormap' in locals() else None,
                width=15,
                interactive=False
            )
            self.colorbar.setImageItem(self.image_item)
            self.graphics_layout.addItem(self.colorbar)

            # 启用鼠标交互功能
            self.enable_rd_mouse_interaction()

            layout.addWidget(self.graphics_layout)

        except Exception as e:
            # 如果PyQtGraph初始化失败，显示错误并降级到提示
            print(f"PyQtGraph RD图初始化失败: {e}")
            import traceback
            traceback.print_exc()
            label = QLabel(f"PyQtGraph RD图初始化失败\n错误: {str(e)}\n请检查PyQtGraph安装")
            label.setAlignment(Qt.AlignCenter)
            label.setStyleSheet("color: #f85149; font-size: 12px; padding: 20px;")
            layout.addWidget(label)

    def clear_plots(self):
        """清空绘图区域 - 提供与matplotlib兼容的接口"""
        if PYQTGRAPH_AVAILABLE and hasattr(self, 'image_item'):
            try:
                # 清空图像数据
                self.image_item.clear()
                # 清空检测点
                for item in self.detection_items:
                    self.plot_item.removeItem(item)
                self.detection_items.clear()
            except Exception as e:
                print(f"清空PyQtGraph RD图失败: {e}")

    def enable_rd_mouse_interaction(self):
        """启用RD图鼠标交互功能"""
        try:
            if hasattr(self, 'plot_item'):
                # 启用鼠标控制
                self.plot_item.setMouseEnabled(x=True, y=True)

                # 获取ViewBox并设置鼠标模式
                vb = self.plot_item.getViewBox()
                vb.setMouseMode(pg.ViewBox.RectMode)  # 矩形选择放大

                # 启用右键菜单
                self.plot_item.setMenuEnabled(True)

                print("[INFO] RD图: 鼠标交互已启用 - 左键选框放大, 右键拖拽平移, 滚轮缩放, 右键菜单重置")

        except Exception as e:
            print(f"启用RD图鼠标交互失败: {e}")

    def plot_rd_map(self, range_axis, doppler_axis, rd_map):
        """绘制距离-多普勒图

        Args:
            range_axis: 距离轴数据（米）
            doppler_axis: 多普勒轴数据（Hz）
            rd_map: RD图数据
        """
        if not PYQTGRAPH_AVAILABLE:
            return

        try:
            # 转换距离轴单位：米 → 千米（用于显示）
            range_axis_km = range_axis / 1000

            # 转换为dB并限制动态范围
            rd_map_db = 20 * np.log10(np.abs(rd_map) + 1e-12)
            max_db = np.max(rd_map_db)
            min_db = max_db - 60  # 60dB动态范围
            rd_map_db = np.clip(rd_map_db, min_db, max_db)

            # 设置图像数据 - 注意坐标轴对应关系
            # rd_map shape: (doppler_bins, range_bins) - FFT后的自然输出
            # PyQtGraph ImageItem显示约定比较特殊:
            # - setImage(data) 中, data的第0维对应图像的x轴(横轴)
            # - data的第1维对应图像的y轴(纵轴)
            #
            # 我们的RD图: (doppler_bins, range_bins)
            # - 第0维 = doppler_bins = 多普勒频率
            # - 第1维 = range_bins = 距离bin
            #
            # 期望显示: x轴=距离, y轴=多普勒 (标准RD图)
            # 因此需要转置: (doppler_bins, range_bins) -> (range_bins, doppler_bins)
            self.image_item.setImage(
                rd_map_db.T,  # 转置: (range_bins, doppler_bins), 使x轴=距离, y轴=多普勒
                autoLevels=False,
                levels=(min_db, max_db)
            )

            # 设置图像的空间坐标范围（使用千米单位）
            # rect参数: (x, y, width, height)
            # x, y: 图像左下角坐标
            # width, height: 图像的宽度和高度
            rect = QRectF(
                range_axis_km[0],  # x起点 (距离最小值, km)
                doppler_axis[0],  # y起点 (多普勒最小值, Hz)
                range_axis_km[-1] - range_axis_km[0],  # 宽度 (距离范围, km)
                doppler_axis[-1] - doppler_axis[0]  # 高度 (多普勒范围, Hz)
            )
            self.image_item.setRect(rect)

            # 更新颜色条范围
            if hasattr(self, 'colorbar'):
                self.colorbar.setLevels((min_db, max_db))

            # 自动调整视图范围
            self.plot_item.autoRange()

        except Exception as e:
            print(f"RD图绘制错误: {e}")
            import traceback
            traceback.print_exc()

    def plot_detections(self, measurements):
        """在RD图上绘制检测点

        Args:
            measurements: 测量结果列表，每个元素包含 'range'(m) 和 'doppler'(Hz)
        """
        if not PYQTGRAPH_AVAILABLE or not measurements:
            return

        try:
            # 清除之前的检测点（不清除RD图）
            for item in self.detection_items:
                self.plot_item.removeItem(item)
            self.detection_items.clear()

            # 提取检测点坐标并转换单位
            ranges_km = []
            dopplers = []
            for measurement in measurements:
                # 转换距离单位：米 → 千米（用于显示）
                range_m = measurement.get('range', 0)
                range_km = range_m / 1000
                ranges_km.append(range_km)
                dopplers.append(measurement.get('doppler', 0))

            if len(ranges_km) > 0:
                # 创建散点图显示检测点
                scatter = pg.ScatterPlotItem(
                    ranges_km, dopplers,
                    pen=pg.mkPen(color='#f85149', width=2),
                    brush=pg.mkBrush(255, 81, 73, 150),  # 半透明红色
                    size=12,
                    symbol='o'
                )
                self.plot_item.addItem(scatter)
                self.detection_items.append(scatter)

        except Exception as e:
            print(f"检测点绘制错误: {e}")
            import traceback
            traceback.print_exc()

    def plot_matrix(self, matrix_data, row_label="脉冲", col_label="距离bin"):
        """
        绘制脉冲压缩矩阵（RD图输入矩阵）

        Args:
            matrix_data: 复数矩阵数据 (num_pulses, range_bins) - 每行是一个脉冲的压缩结果
            row_label: 行标签（默认"脉冲"）
            col_label: 列标签（默认"距离bin"）
        """
        if not PYQTGRAPH_AVAILABLE:
            return

        try:
            # 数据处理：幅度计算、dB转换、动态范围限制
            # 只显示幅度（实部虚部会混淆，幅度更清晰）
            matrix_magnitude = np.abs(matrix_data)

            # 转换为dB并限制动态范围
            matrix_db = 20 * np.log10(matrix_magnitude + 1e-12)
            max_db = np.max(matrix_db)
            min_db = max_db - 60  # 60dB动态范围
            matrix_db = np.clip(matrix_db, min_db, max_db)

            # 设置图像数据
            # matrix_data shape: (num_pulses, range_bins) - 行是脉冲
            # PyQtGraph ImageItem显示约定比较特殊:
            # - setImage(data) 中, data的第0维对应图像的x轴(横轴)
            # - data的第1维对应图像的y轴(纵轴)
            # 这与numpy的常规约定相反!
            #
            # 我们的矩阵: (num_pulses, range_bins)
            # - 第0维 = num_pulses = 脉冲索引 (慢时间)
            # - 第1维 = range_bins = 距离bin
            #
            # 期望显示: x轴=距离, y轴=脉冲
            # 因此需要转置: (num_pulses, range_bins) -> (range_bins, num_pulses)
            self.image_item.setImage(
                matrix_db.T,  # 转置: (range_bins, num_pulses), 使x轴=距离, y轴=脉冲
                autoLevels=False,
                levels=(min_db, max_db)
            )

            # 设置图像的空间坐标范围
            num_pulses, range_bins = matrix_data.shape
            rect = QRectF(
                0,  # x起点（距离bin索引）
                0,  # y起点（脉冲索引）
                range_bins,  # 宽度（距离bin数量）
                num_pulses   # 高度（脉冲数量）
            )
            self.image_item.setRect(rect)

            # 更新坐标轴标签
            self.plot_item.setLabel('bottom', col_label, color='#58a6ff', size='12pt')  # x轴=距离bin
            self.plot_item.setLabel('left', row_label, color='#58a6ff', size='12pt')    # y轴=脉冲

            # 更新颜色条范围
            if hasattr(self, 'colorbar'):
                self.colorbar.setLevels((min_db, max_db))

            # 自动调整视图范围
            self.plot_item.autoRange()

        except Exception as e:
            print(f"矩阵绘制错误: {e}")
            import traceback
            traceback.print_exc()

# 检查PyQtGraph可用性的辅助函数
def is_pyqtgraph_available():
    """检查PyQtGraph是否可用"""
    return PYQTGRAPH_AVAILABLE

def get_performance_info():
    """获取性能优化信息"""
    if PYQTGRAPH_AVAILABLE:
        try:
            # 检查OpenGL状态
            opengl_enabled = pg.getConfigOption('useOpenGL')
            if opengl_enabled:
                try:
                    import OpenGL.GL as gl
                    opengl_status = "硬件加速已启用"
                    performance_note = "最佳性能模式"
                except ImportError:
                    opengl_status = "软件渲染(OpenGL不可用)"
                    performance_note = "安装PyOpenGL可启用硬件加速"
            else:
                opengl_status = "软件渲染"
                performance_note = "仍比matplotlib快10-100倍"

            return {
                'status': 'available',
                'message': f'PyQtGraph可用 - 高性能绘图已启用 ({opengl_status})',
                'expected_speedup': '10-100x 比 matplotlib',
                'performance_note': performance_note,
                'opengl_enabled': opengl_enabled
            }
        except:
            return {
                'status': 'available',
                'message': 'PyQtGraph可用 - 高性能绘图已启用',
                'expected_speedup': '10-100x 比 matplotlib'
            }
    else:
        return {
            'status': 'unavailable',
            'message': 'PyQtGraph不可用 - 请安装以获得高性能',
            'install_command': 'pip install pyqtgraph'
        }